home *** CD-ROM | disk | FTP | other *** search
/ X User Tools / X User Tools (O'Reilly and Associates)(1994).ISO / sources / xbmbrows / xbmbro31.z / xbmbro31 / xbmbrowser3.1 / bitmaps.c next >
C/C++ Source or Header  |  1993-08-05  |  14KB  |  437 lines
  1. /********************************************************************\
  2. **                             _________________________________    **
  3. **   A n t h o n y            |________    __    __    _________|   **
  4. **                                     |  |o_|  |o_|  |             **
  5. **           T h y s s e n           __|   __    __   |__           **
  6. **                                __|   __|  |  |  |__   |__        **
  7. **  `` Dragon Computing! ''    __|   __|     |  |     |__   |__     **
  8. **                            |_____|        |__|        |_____|    **
  9. **                                                                  **
  10. \********************************************************************/
  11. /* 
  12. ** bitmap.c
  13. **
  14. **   This module represents a complete re-write of the data structures used
  15. ** by xbmbrowser to orginise the bitmaps and widgets. These structures
  16. ** although initially created in get_files(), are static to this module.
  17. ** Previously the data structure did not allow for expandsion of bitmap
  18. ** types, storage of pixel colors used, or for checks on modification
  19. ** times.
  20. **                         Anthony Thyssen <anthony@dragon.cit.gu.edu.au>
  21. */
  22. #include "xbmbrowser.h"
  23.  
  24. static Item   *new_file_list = NULL; /* new file list for merging */
  25. static Item   *file_list = NULL;     /* current list of files (& dir) */
  26.  
  27. static Widget *widget_array = NULL;  /* array of widgets available to use */
  28. static int     allocated = 0;        /* number of widgets in above array */
  29. static int     managed = 0;          /* number of widgets being managed */
  30.  
  31. static int file_counts[(int)NumFileTypes]; /* count of the various file types */
  32.  
  33. /*--------------------------------------------------------------------------*/
  34.  
  35. build_dirMenu()
  36. /*  Build the dirMenu from the just read in filelist. It is in this module
  37. ** only because it doesn't seem to fit in other modules.
  38. */
  39. {
  40.   static char *list[256];
  41.   int          list_offset = 0;
  42.   Item        *item = new_file_list;
  43.  
  44.   list[list_offset++] = "/";
  45.   list[list_offset++] = "~/";
  46.  
  47.   /* add to the menu any name in the file list that is a directory */
  48.   while( item != NULL ) {
  49.     if( item->type == Dir )
  50.          list[list_offset++] = item->fname;
  51.     item = item->next;
  52.   }
  53.   list[list_offset] = NULL;
  54.   XtVaSetValues(dirList,XtNdefaultColumns,(XtArgVal)(list_offset/25)+1,NULL);
  55.   XawListChange(dirList,list,0,0,True);
  56. }
  57.  
  58. /*--------------------------------------------------------------------------*/
  59.  
  60. Item *
  61. alloc_item()
  62. /* allocate and default a file item */
  63. {
  64.   Item *item = (Item *) malloc( sizeof(Item) );
  65.  
  66.   item->fname[0] = '\0';
  67.   item->type   = Bad;
  68.   item->bitmap = None;
  69.   item->index  = -1;
  70.   item->next   = NULL;
  71.  
  72.   return item;
  73. }
  74.  
  75.  
  76. Item *
  77. free_item(item)
  78. /* free the item and any aspect about that item. This is the ONLY place
  79. ** where bitmaps are to be freed. Return the next item in list!
  80. */
  81.   Item *item;
  82. {
  83.   Item *next = item->next;
  84.  
  85.   if( item->bitmap != None ) { /* bitmap to be freed ? */
  86.     if( item->index != -1 ) {
  87.       /* remove from bitmap from widget
  88.       ** NOTE: for some reason if the bitmap used by the widget is
  89.       ** set to `None', the XFreePixmap following will coredump!
  90.       */
  91.       XtVaSetValues(widget_array[item->index],
  92.                          XtNbitmap, (XtArgVal)None,  /* None */
  93.                          XtNlabel,  (XtArgVal)NULL,  NULL);
  94.     }
  95.     XFreePixmap(XtDisplay(toplevel), item->bitmap );
  96. #ifdef DO_XPMS
  97.     if( item->type == Xpm ) {
  98.       /* free colors and attributes used by pixmap */
  99.       /* PROBLEM -- what if color is used by another pixmap ? */
  100. #if 0
  101.       XFreeColors(XtDisplay(toplevel),
  102.                    DefaultColormapOfScreen(XtScreen(toplevel)),
  103.                    item->attr.pixels, item->attr.npixels, AllPlanes);
  104. #endif
  105.       XpmFreeAttributes((XpmAttributes *)&item->attr);
  106.     }
  107. #endif
  108.   }
  109.   free( item );
  110.  
  111.   return next;
  112. }
  113.  
  114. static int
  115. read_bitmap(item)
  116. /* attempt to read a bitmap for the item given -- return TRUE if success */
  117.   Item *item;
  118. { 
  119.   int i, status;   /* junk integer, size of icon, return status */
  120.   unsigned int x, y;
  121. #ifdef DO_XPMS
  122.   Pixmap m;              /* junk pixmap mask */
  123. #endif
  124.  
  125.   if( item->type != File )  /* if a not a file -- it can't be a bitmap */
  126.     return FALSE;
  127.  
  128.   /* first try for a X Bitmap file format */
  129.   status = XReadBitmapFile(XtDisplay(toplevel),
  130.                             DefaultRootWindow(XtDisplay(toplevel)),
  131.                             item->fname, &x, &y, &item->bitmap, &i, &i);
  132.   if( status == BitmapSuccess ) {
  133.     item->type = Xbm;
  134.     (void) sprintf(item->info, "\"%s\", %dx%d bitmap", item->fname, x, y);
  135.     return TRUE;
  136.   }
  137.  
  138. #ifdef DO_XPMS
  139.   /* Try a X Pixmap format */
  140.   item->attr.valuemask = XpmReturnPixels | XpmCloseness;
  141.   status = XpmReadPixmapFile(XtDisplay(toplevel),
  142.                             DefaultRootWindow(XtDisplay(toplevel)),
  143.                             item->fname, &item->bitmap,&m,&item->attr);
  144.   switch( status ) {
  145.     case XpmSuccess:
  146.       item->type = Xpm;
  147.       (void) sprintf(item->info, "\"%s\", %dx%d pixmap (%d colors)",
  148.                item->fname, item->attr.width, item->attr.height,
  149.                item->attr.npixels);
  150.       if ( m != None )
  151.         XFreePixmap(XtDisplay(toplevel), m);
  152.       return TRUE;
  153.     case XpmColorFailed:
  154.     case XpmNoMemory:
  155.       item->type = BadXpm;
  156.       if ( item->bitmap != None ) {
  157.         XFreePixmap(XtDisplay(toplevel), item->bitmap);
  158.         item->bitmap = None;
  159.       }
  160.       if ( m != None )
  161.         XFreePixmap(XtDisplay(toplevel), m);
  162.       return FALSE;
  163.    }
  164. #endif
  165.   /* Non Bitmap file */
  166.   item->type = File;    /* unknown plain file -- can't tell */
  167.   item->bitmap = None;
  168.   return 0;
  169. }
  170.  
  171.  
  172. void
  173. free_list(list)
  174. Item **list;   /* pointer to a list pointer */
  175. /* completely free all items in the given item list */
  176. {
  177.   while( *list != NULL )
  178.     *list = free_item( *list );
  179. }
  180.  
  181.  
  182. void
  183. set_label_info()
  184. /* set the contents of the label widgets information string from the
  185. ** current values of the file type counts.  NOTE: watch the string length!
  186. */
  187. {
  188. # define strend  label_info+strlen(label_info)
  189.  
  190.   label_info[0] = '\0';  /* empty the string */
  191.   if( file_counts[Xbm] > 0 )
  192.     sprintf(strend, " %d Bitmaps ",    file_counts[Xbm] );
  193.   if( file_counts[Xpm] > 0 )
  194.     sprintf(strend, " %d Pixmaps ",    file_counts[Xpm] );
  195.   if( file_counts[BadXpm] > 0 )
  196.     sprintf(strend, " %d Can't Show ", file_counts[BadXpm] );
  197.   if( file_counts[File] + file_counts[Bad]  > 0 )
  198.     sprintf(strend, " %d Unknown ",    file_counts[File] + file_counts[Bad] );
  199.   if( file_counts[Dir]-2 > 0 )
  200.     sprintf(strend, " %d Dirs ",       file_counts[Dir]-2 );
  201.  
  202.   XtVaSetValues(lw, XtNlabel, (XtArgVal)label_info, NULL);
  203. # undef strend
  204. }
  205.  
  206. /*------------------------------------------------------------------------*/
  207.  
  208. static void
  209. allocate_widgets( n )
  210. /* create enough widgets to display n bitmaps */
  211.   int n;
  212. {
  213.   char name[8];
  214.   Widget w;
  215.  
  216.   if( allocated == n ) return;   /* just right -- no need to do anthing */
  217.  
  218.   if( allocated < n ) {   /* ok allocate more widgets */
  219.  
  220.     if(widget_array == NULL) {
  221.       widget_array = (Widget *)malloc( n * sizeof(Widget) );
  222.       if( widget_array == NULL ) {
  223.         perror("xbmbrowser: malloc widget_array");
  224.         abort();
  225.       }
  226.     } else {
  227.       widget_array = (Widget *)realloc(widget_array, n * sizeof(Widget) );
  228.       if( widget_array == NULL ) {
  229.         perror("xbmbrowser: realloc larger widget_array");
  230.         abort();
  231.       }
  232.     }
  233.  
  234.     for( ; allocated < n; allocated++ ) {
  235.    
  236.       sprintf(name, "%d", allocated);
  237.       w = XtVaCreateWidget(name, labelWidgetClass, bw, NULL);
  238.       XtOverrideTranslations(w, XtParseTranslationTable(Translations));
  239.       widget_array[allocated] = w;
  240.     }
  241.  
  242.   }
  243. #if 0
  244. /* This code will eventually cause a core dump when lots of directory
  245. ** changes are performed by the user. The problem seems to occur when
  246. ** widgets are really destroyed (they are just flaged for destruction
  247. ** below.  I can't seem to find any problem with the code below however.
  248. ** It just doesn't seem to work.
  249. */
  250.   else {  /* ok we have too many widgets -- remove about a 1/3 of them */
  251.     n = ( allocated + allocated + n ) / 3; /* the final level we want */
  252.     
  253.     for( allocated--; allocated >= n ; allocated-- )
  254.       XtDestroyWidget( widget_array[allocated] );
  255.     allocated++;
  256.  
  257.     widget_array = (Widget *)realloc(widget_array, n * sizeof(Widget) );
  258.     if( widget_array == NULL ) {
  259.       perror("xbmbrowser: realloc smaller widget_array");
  260.       abort();
  261.     }
  262.   }
  263.  
  264.   /* insure that allocated is now equal to n (which may be calculated above */
  265.   assert( allocated == n );
  266. #endif
  267. }
  268.  
  269. static void
  270. merge_bitmaps()
  271. /* Merge the old_file_list that is currently with the new_file_list just 
  272. ** read in. Adjust the new list to reflect any changes to the current
  273. ** directory looking for additions, deletions and modifications to the
  274. ** bitmap files.
  275. */
  276. {
  277.   Item *old_file_list;  /* the old file list that we originally had */
  278.   Item **last_ptr;      /* pointer to the last ponter in the merged list */
  279.   Item *item;           /* general item pointer */
  280.   int   count, cmp;     /* count of bitmaps, filename comparasion */
  281.  
  282.   /* first un-manage all the widgets and free the current file_list
  283.   ** This saves on multiple geometry requests while we do the work
  284.   */
  285.   if( managed > 0 ) {
  286.     XtUnmanageChildren(widget_array, managed);
  287.     managed = 0; 
  288.   }
  289.  
  290.   old_file_list = file_list;   /* make the current list old */
  291.   file_list = NULL;            /* file list (the merger) is empty */
  292.   last_ptr = &file_list;       /* point to the last pointer in empty list */
  293.  
  294.   /* zero all the file_type counts */
  295.   for( count = 0 ; count < NumFileTypes ; count++ )
  296.      file_counts[count] = 0;
  297.   count = 0;  /* count of widgets with valid bitmaps */
  298.  
  299.  
  300.   while( old_file_list != NULL && new_file_list != NULL ) {
  301.     /* items present in both lists */
  302.  
  303.     cmp = strcmp( old_file_list->fname, new_file_list->fname );
  304.     
  305.     if( cmp == 0 ) {
  306.       if ( old_file_list->mtime == new_file_list->mtime ) {
  307.  
  308.         /* NO CHANGE -- same file in both lists without any modifications */
  309.         new_file_list = free_item( new_file_list ); /* junk the new item */
  310.  
  311.     *last_ptr = item = old_file_list;  /* append old item to merged list */
  312.     last_ptr = &(item->next);          /* adjust last_ptr in merged list */
  313.     old_file_list = *last_ptr;         /* remove item from old list */
  314.     /* *last_ptr = NULL;               /* not really nessary */
  315.  
  316.     /* adjust the counts of the file types */
  317.     if( item-> bitmap != None ) count++;
  318.     file_counts[item->type]++;
  319.     continue;
  320.       }
  321.       else {
  322.         /* MODIFIED -- same file but it has been modified or replaced */
  323.         old_file_list = free_item( old_file_list );  /* junk the old item */
  324.         cmp = 1;    /* ok now pretend that the new item is a new addition */
  325.         /* FALL THROUGH */
  326.       }
  327.     }
  328.  
  329.     /* ADDITION -- a new file (or newly modified) to be added to list */
  330.     if( cmp > 0 ) {
  331.       /* a new file added to the directory -- append it to file_list */
  332.       *last_ptr = item = new_file_list;  /* append new item to merged list */
  333.       last_ptr = &(item->next);          /* adjust last_ptr in merged list */
  334.       new_file_list = *last_ptr;         /* remove item from new list */
  335.       /* *last_ptr = NULL;               /* not really nessary */
  336.  
  337.       if( item->type == File  &&  read_bitmap( item ) ) /* read in bitmap */
  338.         count++;                      /* count number of valid bitmaps */
  339.       file_counts[item->type]++;      /* count up the file types */
  340.       continue;
  341.     }
  342.  
  343.     /* DELETION -- the old file has been deleted */
  344.     if( cmp < 0 ) {
  345.       old_file_list = free_item( old_file_list ); /* delete this file */
  346.       continue;
  347.     }
  348.  
  349.     /* this point should never be reached */
  350.     /*NOTREACHED*/
  351.     assert( FALSE );
  352.   }
  353.  
  354.   /*                   --------------
  355.   ** At this point either one or both of the merging file lists
  356.   ** is empty. As such we can just finish of the merged list quickly 
  357.   */
  358.   assert( new_file_list == NULL || old_file_list == NULL );
  359.  
  360.   /* ADD any more new files in the new_file_list */
  361.  
  362.   *last_ptr = new_file_list;   /* the rest of the merged list is new */
  363.   for( item = new_file_list;  item != NULL;  item = item->next ) {
  364.     if( item->type == File  &&  read_bitmap( item ) )
  365.       count++; 
  366.     file_counts[item->type]++;
  367.   }
  368.   new_file_list = NULL;  /* new_file_list is now empty */
  369.      
  370.  
  371.   /* DELETE any old items left in the old_file_list */
  372.   free_list(&old_file_list);
  373.  
  374.   /*                   --------------
  375.   ** Merger of file lists complete. Allocate enough widgets to
  376.   ** hold the bitmaps to be displayed and display them.
  377.   */
  378.   
  379.   /* allocate/deallocate widgets as needed */
  380.   allocate_widgets( count );
  381.  
  382.   /* assign the bitmaps to the widgets in order */
  383.   managed = 0;   /* this should be zero but make sure */
  384.   for( item = file_list;  item != NULL;  item = item->next )
  385.     if( item->bitmap != None ) {
  386.       item->index = managed;
  387.       XtVaSetValues( widget_array[item->index],
  388.                        XtNbitmap, (XtArgVal)item->bitmap,
  389.                        XtNlabel,  (XtArgVal)item->info, NULL); 
  390.       managed++;
  391.     }
  392.  
  393.   /* check the result */
  394.   assert( managed == count );
  395.  
  396.   /* manage the widgets */
  397.   if( managed > 0 )
  398.     XtManageChildren(widget_array, managed);
  399. }
  400.  
  401. /*------------------------------------------------------------------------*/
  402.  
  403. void
  404. scan_bitmaps()
  405. /* scan and display all the bitmaps in the current directory */
  406. {
  407.   /* just free all the bitmaps and do a rescan which handles the
  408.   ** reading of new bitmaps perfectly fine on its own. We need
  409.   ** to unmanage them here, to avoid problems.
  410.   */
  411.   if( managed > 0 ) {
  412.     XtUnmanageChildren(widget_array, managed);
  413.     managed = 0;
  414.   }
  415.   free_list(&file_list);
  416.   rescan_bitmaps();
  417. }
  418.  
  419. void
  420. rescan_bitmaps()
  421. /* Do a fast rescan and merger of the bitmaps in the current directory.
  422. ** The goal is to avoid re-reading files which were never changed.
  423. */
  424. {
  425.   assert( new_file_list == NULL );
  426.   new_file_list = get_files("."); /* the items in the current directory */
  427.   build_dirMenu();                /* build the directory menu from new list */
  428.   merge_bitmaps();                /* merge any changes into file_list */
  429.   set_label_info();               /* show the file counts being displayed */
  430.  
  431.   if( new_file_list != NULL ) {
  432.     fprintf(stderr, "xbmbrowser: bad new_file_list in rescan_bitmaps\n");
  433.     abort();
  434.   }
  435. }
  436.  
  437.